import { useCallback } from "react";
import type { ChatMessage } from "../types/chat";
import type { CreateSessionRequestType } from "../services/chat/createSession";
import queuedApi from "../services/queuedApi";
import { useChatMessage } from "./useChatMessage";
import userService from "../utils/userService";
import type { UploadFile } from "../types/upload";
import requestQueue from "../utils/requestQueue";
import dialogService from "../utils/dialogService";

/**
 * 队列消息处理Hook
 *
 * 处理未登录状态下的消息队列和登录后的消息发送
 */
export function useQueuedMessage() {
  const { sendTextMessage, isLoading, isStreaming, setLoadingState } =
    useChatMessage();

  /**
   * 发送消息（处理登录状态和未登录状态）
   * @param message 消息内容
   * @param selectedModel 选中的模型
   * @param activeChatId 当前活动聊天ID
   * @param files 上传的文件（可选）
   * @param onMessageQueued 消息加入队列时的回调
   * @param onMessageSent 消息发送后的回调
   * @param options 附加选项，如网络搜索等
   */
  const sendMessage = useCallback(
    async (
      message: string,
      selectedModel: { accessCode: string; modelName: string },
      activeChatId: string | null,
      files?: UploadFile[],
      onMessageQueued?: (
        userMessage: ChatMessage,
        systemMessage: ChatMessage
      ) => void,
      onMessageSent?: (response: ChatMessage) => void,
      options?: { isWebSearch?: boolean }
    ) => {
      // 生成唯一的请求ID
      const requestId = `req_${Date.now()}_${Math.random()
        .toString(36)
        .substring(2, 9)}`;

      // 检查用户是否已登录
      if (!userService.isLoggedIn) {
        console.log("[useQueuedMessage] 用户未登录，将消息存入队列");

        // 检查队列中是否已有消息
        const chatRequestCount = requestQueue.getChatRequestCount();
        console.log(
          `[useQueuedMessage] 当前队列中已有 ${chatRequestCount} 条未发送的消息`
        );

        // 仅当队列中已有消息时才显示确认对话框
        if (chatRequestCount > 0) {
          // 获取队列中最后一条消息内容
          const lastMessageContent = requestQueue.getLastChatMessageContent();
          const messagePreview = lastMessageContent
            ? lastMessageContent.length > 50
              ? lastMessageContent.substring(0, 50) + "..."
              : lastMessageContent
            : "未知内容";

          // 弹出确认对话框
          const shouldContinue = await dialogService.warning({
            title: "消息将被替换",
            message: `您有一条未发送的消息正在等待登录后处理:\n\n"${messagePreview}"\n\n如果继续，此消息将被替换为新消息。`,
            confirmText: "继续发送新消息",
            cancelText: "保留原消息",
          });

          // 如果用户取消，则不发送消息
          if (!shouldContinue) {
            console.log("[useQueuedMessage] 用户取消发送，保留原有队列消息");

            // 将队列中的消息标记为确认保留，避免自动显示UI
            requestQueue.markQueuedMessageAsConfirmed();

            return; // 直接返回，不做任何UI状态更改
          }

          // 用户确认继续，清除之前的队列消息，只保留最新的
          console.log("[useQueuedMessage] 用户确认发送，清除之前的队列消息");
        }

        // 创建用户消息和系统提示消息
        const userMessage: ChatMessage = { role: 0, content: message };
        const systemMessage: ChatMessage = {
          role: 2,
          content:
            "您的消息已保存，登录后将自动发送给AI。请点击上方登录按钮继续对话。",
        };

        // 调用回调通知UI更新
        if (onMessageQueued) {
          onMessageQueued(userMessage, systemMessage);
        }

        // 首先将获取模型的请求加入队列，确保它先于聊天请求执行
        queuedApi.get("/ai/model/list", undefined, 1);

        // 准备消息请求参数
        const messageParams = {
          content: message,
          model: selectedModel.modelName,
          sessionId: undefined, // 明确设置为undefined
          ...(files && { files }), // 如果有文件则添加
          // 添加网络搜索选项
          ...(options?.isWebSearch !== undefined && {
            searchNetwork: options.isWebSearch,
          }),
          // 保存原始用户消息，用于登录后显示
          _originalUserMessage: message,
          // 添加请求ID
          _requestId: requestId,
          // 添加自动处理标记（默认为true，表示自动处理）
          _autoProcess: true,
        };

        // 将消息加入队列
        queuedApi.postChat(
          messageParams,
          // UI更新回调 - 在登录后处理队列时会调用
          async () => {
            console.log(
              "[useQueuedMessage] 登录后执行队列中的消息，显示用户消息:",
              message
            );

            // 显示加载状态
            setLoadingState(true, true);

            // 确保UI中显示用户消息
            // 注意：此时可能UI中已经有了用户消息，所以我们需要检查
            if (onMessageSent) {
              // 创建AI响应的骨架占位符
              const placeholderMessage: ChatMessage = {
                role: 1,
                content: "",
                isPlaceholder: true,
                requestId: requestId,
              };

              // 通知UI添加占位符
              onMessageSent(placeholderMessage);
            }

            // 重要修复：队列请求执行后，使用sendTextMessage建立SSE连接处理响应
            try {
              console.log("[useQueuedMessage] 为队列消息建立SSE连接");

              // 构建会话请求参数
              const sessionRequest: CreateSessionRequestType = {
                sessionId: undefined, // 新会话
                content: message,
                model: selectedModel.modelName,
                ...(options?.isWebSearch !== undefined && {
                  searchNetwork: options.isWebSearch,
                }),
              };

              // 发送消息并建立SSE连接处理流式响应
              await sendTextMessage(sessionRequest, (partialResponse, done) => {
                // 确保loading状态已关闭，但保持streaming状态
                setLoadingState(false, true);

                // 更新消息内容
                if (onMessageSent) {
                  onMessageSent({
                    ...partialResponse,
                    requestId: requestId,
                    isPlaceholder: !done, // 流结束后移除占位符标记
                  });
                }

                // 流处理完成后更新状态
                if (done) {
                  setLoadingState(false, false);
                }
              });
            } catch (error) {
              console.error("[useQueuedMessage] 队列消息处理失败:", error);
              // 重置加载和流状态
              setLoadingState(false, false);

              // 如果有回调，发送错误消息
              if (onMessageSent) {
                onMessageSent({
                  role: 2, // 系统消息
                  content: `发送消息失败: ${
                    error instanceof Error ? error.message : "未知错误"
                  }`,
                  requestId: requestId,
                  isPlaceholder: false,
                });
              }
            }
          }
        );

        return;
      }

      // 用户已登录，直接发送消息
      setLoadingState(true, true);

      // 创建会话请求参数
      const sessionRequest: CreateSessionRequestType = {
        sessionId:
          activeChatId && !activeChatId.startsWith("chat_")
            ? activeChatId
            : undefined,
        content: message,
        model: selectedModel.modelName,
        // 添加网络搜索选项
        ...(options?.isWebSearch !== undefined && {
          searchNetwork: options.isWebSearch,
        }),
      };

      console.log("[useQueuedMessage] 发送消息请求参数:", {
        sessionId: sessionRequest.sessionId,
        model: sessionRequest.model,
        searchNetwork: sessionRequest.searchNetwork,
        requestId: requestId,
      });

      // 创建AI消息占位符
      const placeholderMessage: ChatMessage = {
        role: 1,
        content: "",
        isPlaceholder: true,
        requestId: requestId,
      };

      // 通知UI添加占位符
      if (onMessageSent) {
        onMessageSent(placeholderMessage);
      }

      try {
        // 在开始接收流数据时就关闭loading状态，但保持streaming状态
        setLoadingState(false, true);

        // 发送消息并处理流式响应
        await sendTextMessage(sessionRequest, (partialResponse, done) => {
          // 当接收到第一个数据块时，确保loading状态已关闭
          setLoadingState(false, true);

          // 更新消息内容（仅当消息属于当前会话时）
          if (onMessageSent) {
            onMessageSent({
              ...partialResponse,
              requestId: requestId,
              isPlaceholder: !done, // 流结束后移除占位符标记
            });
          }

          // 流处理完成后更新状态
          if (done) {
            setLoadingState(false, false);
          }
        });
      } catch (error) {
        // 处理错误，确保更新UI状态
        console.error("[useQueuedMessage] 发送消息失败:", error);

        // 重置加载和流状态
        setLoadingState(false, false);

        // 如果有回调，发送错误消息
        if (onMessageSent) {
          onMessageSent({
            role: 2, // 系统消息
            content: `发送消息失败: ${
              error instanceof Error ? error.message : "未知错误"
            }`,
            requestId: requestId,
            isPlaceholder: false, // 这是最终消息，不是占位符
          });
        }
      }
    },
    [sendTextMessage, setLoadingState]
  );

  /**
   * 检查会话是否有活动响应（始终返回false，因为已移除响应跟踪器）
   */
  const hasActiveResponse = useCallback(() => {
    return false;
  }, []);

  return {
    sendMessage,
    isLoading,
    isStreaming,
    hasActiveResponse,
  };
}
